Reflect new (id, handler, options) signature.

The Before cell used Default::default() on RegisterFunctionMessage,
which does not derive Default. Replace with the existing
.with_id(...).with_description(...) builder.

…shape

The reshaped register_function_with(id, handler, options) signature
references RegisterFunctionOptions. Add it to EXPORTED_TYPES so its
section renders in the regenerated API reference.

Drop reg_fn_msg helper and update all 32 call sites to the new
(id, handler, options) shape after iii-sdk's BREAKING change.

BREAKING CHANGE: registration call sites changed shape; no behavioral
change.

Reflect new (id, handler, options) signature in the SKILL.md table
and the http-invoked-functions.rs reference snippet.

The auto-generated SDK reference dropped HttpInvocationConfig,
HttpAuthConfig, HttpMethod, FunctionInfo, TriggerInfo, WorkerInfo,
and RegisterFunctionMessage sections after register_function_with's
signature stopped naming HttpInvocationConfig directly. Those types
are still referenced in method/type doc-comments via intra-doc links
(e.g., 'Async closure or [HttpInvocationConfig]'). Extend
filterReferencedTypes to also scan description fields and examples,
so types named in prose stay in the rendered output.

Symmetric fix lands sdk-python.mdx changes too: ChannelReader,
ChannelWriter, TriggerAction, EnqueueResult, StreamChannelRef,
EngineLogExporter, EngineMetricsExporter, Trigger, TriggerTypeRef,
and Channel are also referenced only in prose (e.g. ':meth:' /
'\`\`trigger()\`\`') and were dropped for the same reason.

Replace the prior register_function / register_function_with /
RegisterFunction tuple split with a single API:

    iii.register_function(id, RegisterFunction::new_async(fetch).description(...));

Constructors carry the registration kind:

    RegisterFunction::new(f)        // sync typed (auto-extracted schemas)
    RegisterFunction::new_async(f)  // async typed (auto-extracted schemas)
    RegisterFunction::raw(f)        // async untyped Value handler
    RegisterFunction::http(config)  // HTTP-invoked

Builder methods (chainable, all consume self):

    .description(s) .metadata(v)
    .request_format(schema) .response_format(schema)

When request_format / response_format are set on the builder they
override any auto-extracted schemas.

Removed:

  * register_function_with
  * register_function((RegisterFunctionMessage, handler)) tuple form
  * RegisterFunctionOptions
  * IntoFunctionRegistration trait
  * IntoFunctionHandler trait + impls
  * iii_fn / iii_async_fn / IIIFn / IIIAsyncFn

Migrated all in-tree consumers: SDK integration tests, iii-example
crate, console-rust (33 callers), and three engine bridges. Skill
references and the changelog entry rewritten. docs/api-reference/
sdk-rust.mdx regenerated.

BREAKING CHANGE: register_function_with, RegisterFunctionOptions,
the (RegisterFunctionMessage, handler) tuple form, IntoFunctionHandler,
IntoFunctionRegistration, iii_fn/iii_async_fn/IIIFn/IIIAsyncFn are all
removed. See docs/changelog/0-11-0/align-rust-register-function-with-signature.mdx
for the migration table.

CI surfaced two issues with the prior commit:

1. crates/iii-worker/src/sandbox_daemon/{mod,fs/*}.rs (14 sites)
   were still using the old register_function_with(message, handler)
   signature — never picked up by the previous migration sweep, which
   only searched sdk/, console/, engine/, and skills/. Migrated to the
   new register_function(id, RegisterFunction::raw(handler).description(...))
   shape.

2. The migration script's output had inconsistent spacing that
   tripped cargo fmt --check across the workspace. Ran cargo fmt --all
   to fix.

Verified locally:
- cargo build --workspace --all-targets — clean
- cargo fmt --all -- --check — clean
- cargo test -p iii-sdk --lib — 64/64 pass
- cargo test -p iii-sdk --doc — 16/16 pass

The 'untyped' name is more self-explanatory: it pairs cleanly with the
typed 'new' / 'new_async' constructors and signals 'no schema
introspection' rather than implying low-level access.

Pure mechanical rename across all consumers, the changelog, the API
reference, and skill docs. No behavioral change.

… IIIError

Drop RegisterFunction::untyped — `serde_json::Value: JsonSchema` (via
schemars), so `RegisterFunction::new` and `::new_async` already accept
both typed handlers AND `Fn(Value) -> ...` closures. The `untyped`
constructor was redundant.

To make this work without forcing every caller to write
`Ok::<_, IIIError>(...)` annotations, fix the handler error type to
`IIIError` (was generic `E: Display`):

    // Before
    F: Fn(T) -> Result<R, E>
    E: Display + Send + 'static

    // After
    F: Fn(T) -> Result<R, IIIError>

Add `From<String>` and `From<&str>` for `IIIError` to smooth the
migration of existing handlers returning `Result<R, String>`.

Constructors are now 3:
- `RegisterFunction::new(f)`        — sync, typed or Value
- `RegisterFunction::new_async(f)`  — async, typed or Value
- `RegisterFunction::http(config)`  — HTTP-invoked

Migration:
- `RegisterFunction::untyped(f)` -> `RegisterFunction::new_async(f)` (~118 sites)
- `Result<R, String>` -> `Result<R, IIIError>` (~40 sites in iii-example, tests)
- Closures with implicit `_input` -> `_input: Value` for inference (~3 sites)

BREAKING CHANGE: handler signatures now require `Result<_, IIIError>`.
Use `IIIError::Handler(s)`, `Err(s.into())`, or `?`-propagation instead
of `Err(string)`.

- queue_integration.rs: switch durable test function IDs from dot-
  separated (test.queue.foo.rs.X) to ::-separated (test::queue::foo::rs::X)
  to match the repo standard.
- iii.rs: drop the duplicated RegisterFunction::new_async entry from the
  register_function rustdoc (the API has 3 constructors, not 4).
- changelog: distinguish sync vs async replacements in the migration
  table — register_function_with and the tuple form map to either
  RegisterFunction::new or RegisterFunction::new_async depending on the
  handler kind.
- changelog: fix Python signature parameter name from `handler` to
  `handler_or_invocation` (keeping the `*` keyword-only marker since the
  real Python API does require it).

- IntoSyncHandler / IntoAsyncHandler: map serde_json::from_value and
  serde_json::to_value failures to IIIError::Serde instead of
  IIIError::Handler. Preserves the distinction between user handler
  errors and SDK-level (de)serialization errors.
- iii.rs rustdoc: replace bare ids "greet" / "echo" in the
  register_function examples with the repo's ::-separated convention
  ("greetings::greet" / "debug::echo") to match other examples.

- Add `From<SandboxErrorWire> for IIIError` so the sandbox_daemon
  handlers can map their wire-error directly into the new
  `Result<R, IIIError>` constraint introduced by the handler-error
  type collapse.
- Map `SandboxErrorWire` through the new From impl in sandbox_daemon
  registrations.
- Restore `BaggageSpanProcessor`, `DEFAULT_ALLOWLIST`, span_ops helpers,
  and `run_with_baggage` to the top-level SDK re-exports (kept by main
  after the telemetry-export cleanup) so `engine` and the SDK test
  suite resolve them again.
- Port `raw_json_request_body` to the new
  `register_function(id, RegisterFunction::new_async(...))` shape.
- Drop the `register_service` leftover in `registration_dedup` and pick
  up `IIIError` from the SDK re-exports.

cargo fmt --all.

The `worker` custom trigger e2e tests landed on main with the
pre-rebase `register_function(RegisterFunction::new_async(id, ...))`
shape. Port to the new
`register_function(id, RegisterFunction::new_async(...))` form and
change the closure error type to `IIIError`.